"""
AI 服务实现
"""
import threading
import time
import json
import os
import uuid
from typing import Dict, Any, Optional, List, Callable
from datetime import datetime

from app.services.ai_service import IAIService
from app.services.speech_service import ISpeechService
from app.services.script_service import IScriptService
from app.services.base_service import Event
from app.models.comment import Comment
from app.utils.logger import Logger

# 导入 Coze API 相关库
from cozepy import (
    Coze, TokenAuth, Message, ChatStatus, MessageContentType, 
    COZE_CN_BASE_URL, ChatEventType
)


class AIService(IAIService):
    """
    AI 服务实现
    """
    
    def __init__(self):
        """
        初始化 AI 服务
        """
        super().__init__()
        
        # 获取日志记录器
        self.logger = Logger.get_logger("ai_service")
        
        # 语音服务
        self._speech_service: Optional[ISpeechService] = None
        
        # 脚本服务
        self._script_service: Optional[IScriptService] = None
        
        # 配置
        self._config: Dict[str, Any] = {
            "prompt_template": "{comment}",
            "max_tokens": 100,
            "temperature": 0.7,
            "auto_reply": False,
            "auto_speech": False,
            "token": "",
            "stream_mode": True,
            "bot_id": None,
            "user_id": "system_user",
            "conversation_id": None
        }
        
        # Coze API 客户端
        self._coze = None
        
        # 分析线程池
        self._analysis_threads: List[threading.Thread] = []
        
        # 回复线程池
        self._reply_threads: List[threading.Thread] = []
        
        # 最大线程数
        self._max_threads = 5
        
        # 是否正在运行
        self._running = True
        
        # 事件监听器字典，键为事件类型，值为监听器列表
        self._listeners: Dict[str, List[Callable[[Event], None]]] = {}
        
        # 会话缓存，格式: {bot_id: {conversation_id: name}}
        self._conversations = {}
        
        # 消息处理队列，格式: [{"comment": comment, "prompt": prompt, "timestamp": time.time(), "type": "analyze"/"reply"}]
        self._message_queue = []
        
        # 是否正在处理消息
        self._is_processing = False
        
        # 队列锁，用于线程安全地操作队列
        self._queue_lock = threading.Lock()
        
        # 当前处理的记录ID
        self._current_record_id = None
        
        self.logger.info("AI 服务初始化完成")
        
        # 尝试从配置加载并连接 Coze
        self._try_connect_coze()
    
    def _try_connect_coze(self):
        """
        尝试连接 Coze API
        """
        token = self._config.get("token", "")
        if token:
            try:
                self._coze = Coze(
                    auth=TokenAuth(token=token),
                    base_url=COZE_CN_BASE_URL
                )
                
                # 测试连接
                list(self._coze.workspaces.list())
                self.logger.info("Coze API 连接成功")
                
                # 如果有保存的 bot_id 和 conversation_id，尝试恢复
                self._restore_last_state()
                
                return True
            except Exception as e:
                self._coze = None
                self.logger.error(f"Coze API 连接失败: {str(e)}")
                return False
        return False
    
    def _restore_last_state(self):
        """
        恢复上次的状态
        """
        bot_id = self._config.get("bot_id")
        conversation_id = self._config.get("conversation_id")
        
        if bot_id and conversation_id:
            self.logger.info(f"尝试恢复上次状态: bot_id={bot_id}, conversation_id={conversation_id}")
            
            # 获取机器人列表并通知UI更新
            try:
                # 发送连接成功事件，触发UI刷新机器人列表
                self.notify("ai_connection_status", "success")
                
                # 如果有会话ID，尝试获取该机器人的会话列表
                if bot_id in self._conversations:
                    # 清除缓存，强制重新获取
                    self._conversations[bot_id] = {}
                
                # 获取会话列表
                conversations = self.get_conversations(bot_id)
                self.logger.info(f"恢复状态：获取到 {len(conversations)} 个会话")
            except Exception as e:
                self.logger.error(f"恢复状态时获取机器人或会话列表失败: {str(e)}")
        else:
            self.logger.info("没有找到上次的状态信息")
    
    def add_listener(self, event_type: str, listener: Callable[[Event], None]) -> None:
        """
        添加事件监听器
        
        @param event_type: 事件类型
        @param listener: 监听器函数，接收一个 Event 参数
        """
        if event_type not in self._listeners:
            self._listeners[event_type] = []
        
        if listener not in self._listeners[event_type]:
            self._listeners[event_type].append(listener)
    
    def remove_listener(self, event_type: str, listener: Callable[[Event], None]) -> bool:
        """
        移除事件监听器
        
        @param event_type: 事件类型
        @param listener: 监听器函数
        @return: 是否成功移除
        """
        if event_type in self._listeners and listener in self._listeners[event_type]:
            self._listeners[event_type].remove(listener)
            return True
        return False
    
    def clear_listeners(self, event_type: str = None) -> None:
        """
        清除事件监听器
        
        @param event_type: 事件类型，如果为 None 则清除所有监听器
        """
        if event_type is None:
            self._listeners.clear()
        elif event_type in self._listeners:
            self._listeners[event_type].clear()
    
    def notify(self, event_type: str, data: Any = None) -> None:
        """
        通知事件
        
        @param event_type: 事件类型
        @param data: 事件数据
        """
        # 创建事件对象
        event = Event(event_type, data)
        
        # 调用监听器
        if event_type in self._listeners:
            for listener in self._listeners[event_type]:
                try:
                    listener(event)
                except Exception as e:
                    self.logger.error(f"事件监听器异常: {str(e)}")
    
    def analyze_comment(self, comment: Comment) -> Dict[str, Any]:
        """
        分析评论
        
        @param comment: 评论对象
        @return: 分析结果
        """
        try:
            # 获取评论内容
            content = comment.content
            self.logger.info(f"开始分析评论: ID={comment.id}, 内容={content}")
            
            # 使用脚本服务查找匹配的脚本
            script = None
            if self._script_service:
                self.logger.info(f"检查脚本匹配: ID={comment.id}")
                script = self._script_service.find_matching_script(content)
                if script:
                    self.logger.info(f"找到匹配脚本: ID={script.get('id', 'unknown')}")
                else:
                    self.logger.info(f"未找到匹配脚本，将使用AI生成回复: ID={comment.id}")
            else:
                self.logger.warning(f"脚本服务未设置，跳过脚本匹配: ID={comment.id}")
            
            # 如果找到匹配的脚本，使用脚本生成回复
            if script:
                reply = script.get("reply", "")
                self.logger.info(f"使用脚本回复评论: ID={comment.id}, 内容={content}, 回复={reply}")
                
                # 更新评论对象
                comment.reply = reply
                
                # 创建分析结果
                result = {
                    "comment_id": comment.id,
                    "reply": reply,
                    "source": "script",
                    "script_id": script.get("id"),
                    "timestamp": time.time()
                }
                
                # 触发评论分析事件
                self.notify("comment_analyzed", result)
                
                # 如果配置了自动语音合成，则合成语音
                if self._config.get("auto_speech", False) and self._speech_service:
                    self.logger.info(f"开始语音合成: ID={comment.id}, 文本={reply}")
                    self._speech_service.synthesize(reply)
                else:
                    self.logger.debug(f"跳过语音合成: auto_speech={self._config.get('auto_speech', False)}, speech_service={self._speech_service is not None}")
                
                return result
            
            # 否则使用 AI 生成回复
            self.logger.info(f"开始使用AI生成回复: ID={comment.id}")
            reply = self.generate_reply(comment)
            self.logger.info(f"AI生成回复完成: ID={comment.id}, 回复={reply}")
            
            # 更新评论对象
            comment.reply = reply
            
            # 创建分析结果
            result = {
                "comment_id": comment.id,
                "reply": reply,
                "source": "ai",
                "timestamp": time.time()
            }
            
            # 触发评论分析事件
            self.logger.info(f"触发AI评论分析完成事件: ID={comment.id}")
            self.notify("comment_analyzed", result)
            
            # 如果配置了自动语音合成，则合成语音
            if self._config.get("auto_speech", False) and self._speech_service:
                self.logger.info(f"开始语音合成: ID={comment.id}, 文本={reply}")
                self._speech_service.synthesize(reply)
            else:
                self.logger.debug(f"跳过语音合成: auto_speech={self._config.get('auto_speech', False)}, speech_service={self._speech_service is not None}")
            
            return result
        except Exception as e:
            self.logger.error(f"分析评论失败: {str(e)}")
            return {
                "comment_id": comment.id,
                "error": str(e),
                "timestamp": time.time()
            }
    
    def analyze_comment_async(self, comment: Comment) -> None:
        """
        异步分析评论
        
        @param comment: 评论对象
        """
        self.logger.info(f"开始异步分析评论: ID={comment.id}, 用户={comment.user_name}, 内容={comment.content}")
        
        # 使用队列处理机制
        self._add_to_queue(comment, type="analyze")
    
    def generate_reply(self, comment: Comment, prompt: Optional[str] = None) -> str:
        """
        生成回复
        
        @param comment: 评论对象
        @param prompt: 提示词
        @return: 生成的回复
        """
        try:
            # 检查 Coze 客户端是否已初始化
            if not self._coze:
                if not self._try_connect_coze():
                    raise Exception("Coze API 未连接")
            
            # 检查是否已选择机器人和会话
            if not self._config.get("bot_id"):
                raise Exception("未选择机器人")
            
            if not self._config.get("conversation_id"):
                # 如果没有会话，创建一个新会话
                try:
                    conversation = self._coze.conversations.create()
                    self._config["conversation_id"] = conversation.id
                    self.logger.info(f"已创建新会话: {conversation.id}")
                except Exception as e:
                    raise Exception(f"创建会话失败: {str(e)}")
            
            # 获取评论内容和用户名
            content = comment.content
            username = comment.user_name
            
            # 构建带用户名的内容
            formatted_content = f"用户'{username}'说: {content}"
            
            # 使用提示词模板
            if prompt:
                # 如果提供了自定义提示词，直接使用
                prompt_text = prompt
            else:
                # 否则使用配置中的模板，将评论内容替换为带用户名的格式
                template = self._config.get("prompt_template", "{comment}")
                prompt_text = template.format(comment=formatted_content)
            
            # 记录当前处理的评论ID
            self._current_record_id = comment.id
            
            # 记录将发送给AI的完整内容
            self.logger.info(f"[generate_reply] 用户名: {username}, 评论内容: {content}")
            self.logger.info(f"[generate_reply] 将发送给Coze API的提示词: {prompt_text}")
            self.logger.info(f"[generate_reply] 机器人ID: {self._config.get('bot_id')}, 会话ID: {self._config.get('conversation_id')}")
            
            # 根据流式模式选择不同的处理方式
            if self._config.get("stream_mode", True):
                # 流式对话
                complete_message = ""
                for event in self._coze.chat.stream(
                    bot_id=self._config["bot_id"],
                    user_id=self._config["user_id"],
                    conversation_id=self._config["conversation_id"],
                    additional_messages=[
                        Message.build_user_question_text(prompt_text)
                    ]
                ):
                    if event.event == ChatEventType.CONVERSATION_MESSAGE_DELTA:
                        # 累积完整消息
                        complete_message += event.message.content
                    elif event.event == ChatEventType.CONVERSATION_CHAT_COMPLETED:
                        # 尝试解析完整消息为JSON
                        try:
                            if complete_message.strip().startswith('{') and complete_message.strip().endswith('}'):
                                json_data = json.loads(complete_message)
                                if isinstance(json_data, dict) and 'result' in json_data:
                                    return json_data['result']
                        except json.JSONDecodeError:
                            pass
                        
                        # 如果JSON解析失败，返回原始消息
                        return complete_message
            else:
                # 非流式对话
                chat = self._coze.chat.create(
                    bot_id=self._config["bot_id"],
                    user_id=self._config["user_id"],
                    conversation_id=self._config["conversation_id"],
                    additional_messages=[
                        Message.build_user_question_text(prompt_text)
                    ]
                )
                
                # 轮询等待对话完成
                start_time = time.time()
                timeout = 60  # 60秒超时
                
                while chat.status == ChatStatus.IN_PROGRESS:
                    if time.time() - start_time > timeout:
                        raise Exception("对话超时")
                        
                    time.sleep(1)  # 每秒轮询一次
                    chat = self._coze.chat.retrieve(
                        conversation_id=self._config["conversation_id"],
                        chat_id=chat.id
                    )
                
                if chat.status == ChatStatus.COMPLETED:
                    # 获取所有消息
                    messages = list(self._coze.chat.messages.list(
                        conversation_id=self._config["conversation_id"],
                        chat_id=chat.id
                    ))
                    
                    # 找到最新的assistant消息
                    assistant_message = None
                    for message in messages:
                        if message.role == "assistant":
                            assistant_message = message
                            break
                    
                    if assistant_message:
                        try:
                            if assistant_message.content.strip().startswith('{') and assistant_message.content.strip().endswith('}'):
                                json_data = json.loads(assistant_message.content)
                                if isinstance(json_data, dict) and 'result' in json_data:
                                    return json_data['result']
                        except json.JSONDecodeError:
                            pass
                        
                        return assistant_message.content
                else:
                    raise Exception("对话未完成或已超时")
            
            # 如果没有返回，返回默认回复
            return f'谢谢你的评论："{content}"，我们很高兴收到你的反馈！'
            
        except Exception as e:
            self.logger.error(f"生成回复失败: {str(e)}")
            return f"抱歉，无法生成回复: {str(e)}"
    
    def generate_reply_async(self, comment: Comment, prompt: Optional[str] = None) -> None:
        """
        异步生成回复
        
        @param comment: 评论对象
        @param prompt: 提示词
        """
        self.logger.info(f"开始异步生成回复: ID={comment.id}, 用户={comment.user_name}, 内容={comment.content}")
        
        # 使用队列处理机制
        self._add_to_queue(comment, prompt=prompt, type="reply")
    
    def configure(self, config: Dict[str, Any]) -> None:
        """
        配置 AI 服务
        
        @param config: 配置字典
        """
        # 检查是否有实际的配置变更
        has_changes = False
        for key, value in config.items():
            if key in self._config and self._config[key] != value:
                has_changes = True
                self._config[key] = value
        
        # 如果没有实际变更，则跳过后续处理
        if not has_changes:
            self.logger.info("AI 服务配置未发生变化，跳过更新")
            return
            
        # 如果更新了 token，尝试连接 Coze
        if "token" in config and config["token"]:
            token = config["token"]
            # 检查token是否变化或Coze客户端是否未初始化
            if self._coze is None or token != getattr(self._coze.auth, 'token', None):
                try:
                    self._coze = Coze(
                        auth=TokenAuth(token=token),
                        base_url=COZE_CN_BASE_URL
                    )
                    
                    # 测试连接
                    list(self._coze.workspaces.list())
                    self.logger.info("Coze API 连接成功")
                    
                    # 发送连接成功事件
                    self.notify("ai_connection_status", "success")
                    
                    # 主动获取机器人列表
                    try:
                        bots = self.get_bots()
                        self.logger.info(f"获取到 {len(bots)} 个机器人")
                    except Exception as e:
                        self.logger.error(f"获取机器人列表失败: {str(e)}")
                    
                    # 如果有保存的 bot_id 和 conversation_id，尝试恢复
                    self._restore_last_state()
                except Exception as e:
                    self._coze = None
                    self.logger.error(f"Coze API 连接失败: {str(e)}")
                    
                    # 发送连接失败事件
                    self.notify("ai_connection_status", "failed")
            else:
                self.logger.info("Coze API 已连接，跳过重新初始化")
        
        # 记录日志
        self.logger.info("AI 服务配置已更新")
    
    def set_speech_service(self, speech_service: ISpeechService) -> None:
        """
        设置语音服务
        
        @param speech_service: 语音服务实例
        """
        self._speech_service = speech_service
        self.logger.info("语音服务已设置")
    
    def set_script_service(self, script_service: IScriptService) -> None:
        """
        设置脚本服务
        
        @param script_service: 脚本服务实例
        """
        self._script_service = script_service
        self.logger.info("脚本服务已设置")
    
    def shutdown(self) -> None:
        """
        关闭 AI 服务
        """
        self._running = False
        
        # 等待所有线程完成
        for thread in self._analysis_threads:
            if thread.is_alive():
                thread.join(timeout=1.0)
        
        for thread in self._reply_threads:
            if thread.is_alive():
                thread.join(timeout=1.0)
        
        # 清空消息队列
        with self._queue_lock:
            queue_length = len(self._message_queue)
            if queue_length > 0:
                self.logger.info(f"关闭时清空队列，剩余消息数: {queue_length}")
            self._message_queue.clear()
            self._is_processing = False
        
        self.logger.info("AI 服务已关闭")
    
    def get_bots(self) -> List[Dict[str, Any]]:
        """
        获取机器人列表
        
        @return: 机器人列表
        """
        if not self._coze:
            if not self._try_connect_coze():
                return []
        
        bots = []
        try:
            workspaces = list(self._coze.workspaces.list())
            for workspace in workspaces:
                try:
                    workspace_bots = list(self._coze.bots.list(space_id=workspace.id))
                    for bot in workspace_bots:
                        bot_info = {
                            'bot_id': bot.bot_id,
                            'bot_name': bot.bot_name,
                            'workspace_id': workspace.id,
                            'workspace_name': workspace.name,
                            'display_name': f"{bot.bot_name} - {workspace.name}"
                        }
                        bots.append(bot_info)
                except Exception as e:
                    self.logger.error(f"获取工作空间 {workspace.name} 的机器人列表失败: {str(e)}")
        except Exception as e:
            self.logger.error(f"获取机器人列表失败: {str(e)}")
        
        return bots
    
    def create_conversation(self, name: str = None) -> str:
        """
        创建新会话
        
        @param name: 会话名称
        @return: 会话ID
        """
        if not self._coze:
            if not self._try_connect_coze():
                raise Exception("Coze API 未连接")
        
        if not self._config.get("bot_id"):
            raise Exception("未选择机器人")
        
        try:
            conversation = self._coze.conversations.create()
            conversation_id = conversation.id
            
            # 确保bot_id的会话字典存在
            bot_id = self._config["bot_id"]
            if bot_id not in self._conversations:
                self._conversations[bot_id] = {}
            
            # 如果没有提供名称，使用时间戳
            if not name:
                name = f"会话 {datetime.now().strftime('%Y-%m-%d %H:%M:%S')}"
            
            self._conversations[bot_id][conversation_id] = name
            
            # 更新当前会话ID
            self._config["conversation_id"] = conversation_id
            
            # 添加以下代码：发送状态更新事件
            self.notify("conversation_created", {
                "conversation_id": conversation_id,
                "name": name,
                "status": "已连接"
            })
            
            self.logger.info(f"已创建新会话: {name} ({conversation_id})")
            return conversation_id
        except Exception as e:
            self.logger.error(f"创建会话失败: {str(e)}")
            raise
    
    def get_conversations(self, bot_id: str = None) -> Dict[str, str]:
        """
        获取会话列表
        
        @param bot_id: 机器人ID，如果为None则使用当前机器人
        @return: 会话字典，格式: {conversation_id: name}
        """
        self.logger.info(f"获取会话列表，bot_id: {bot_id}")
        
        if bot_id is None:
            bot_id = self._config.get("bot_id")
            self.logger.info(f"使用当前机器人 ID: {bot_id}")
            if not bot_id:
                self.logger.warning("未设置机器人 ID")
                return {}
        
        # 如果缓存中已有该机器人的会话列表，直接返回
        if bot_id in self._conversations and self._conversations[bot_id]:
            self.logger.info(f"从缓存中获取会话列表，共 {len(self._conversations[bot_id])} 个会话")
            return self._conversations[bot_id]
        
        # 否则从 Coze API 获取会话列表
        if not self._coze:
            if not self._try_connect_coze():
                self.logger.error("Coze API 连接失败，无法获取会话列表")
                return {}
        
        try:
            self.logger.info(f"从 Coze API 获取会话列表，bot_id: {bot_id}")
            
            # 确保 bot_id 的会话字典存在
            if bot_id not in self._conversations:
                self._conversations[bot_id] = {}
            
            # 创建一个默认会话
            try:
                self.logger.info(f"为机器人 {bot_id} 创建一个默认会话")
                conversation = self._coze.conversations.create()
                self._conversations[bot_id][conversation.id] = "默认会话"
                self.logger.info(f"创建默认会话成功，ID: {conversation.id}")
            except Exception as e:
                self.logger.error(f"创建默认会话失败: {str(e)}")
                import traceback
                self.logger.error(traceback.format_exc())
            
            # 获取会话列表
            self.logger.info("开始获取会话列表...")
            try:
                conversations = list(self._coze.conversations.list(bot_id=bot_id))
                self.logger.info(f"获取到 {len(conversations)} 个会话")
                
                # 更新会话缓存
                for conversation in conversations:
                    # 使用会话 ID 的前 8 位作为名称
                    name = f"会话 {conversation.id[:8]}"
                    self._conversations[bot_id][conversation.id] = name
                    self.logger.info(f"添加会话: {name}, ID: {conversation.id}")
            except Exception as e:
                self.logger.error(f"获取会话列表失败: {str(e)}")
                import traceback
                self.logger.error(traceback.format_exc())
            
            # 如果没有会话，创建一个默认会话
            if not self._conversations[bot_id]:
                self.logger.warning(f"机器人 {bot_id} 没有会话，创建一个测试会话")
                # 创建一个测试会话
                self._conversations[bot_id]["test_conversation_id"] = "测试会话"
                self.logger.info("创建测试会话成功")
            
            self.logger.info(f"最终获取到 {len(self._conversations[bot_id])} 个会话")
            return self._conversations[bot_id]
        except Exception as e:
            self.logger.error(f"获取会话列表失败: {str(e)}")
            import traceback
            self.logger.error(traceback.format_exc())
            
            # 创建一个测试会话
            if bot_id not in self._conversations:
                self._conversations[bot_id] = {}
            self._conversations[bot_id]["test_conversation_id"] = "测试会话"
            self.logger.info("创建测试会话成功")
            
            return self._conversations[bot_id]
    
    def _add_to_queue(self, comment: Comment, prompt: Optional[str] = None, type: str = "analyze") -> None:
        """
        添加评论到处理队列
        
        @param comment: 评论对象
        @param prompt: 提示词
        @param type: 处理类型，"analyze"或"reply"
        """
        with self._queue_lock:
            # 将评论添加到队列
            queue_item = {
                "comment": comment,
                "prompt": prompt,
                "timestamp": time.time(),
                "type": type
            }
            self._message_queue.append(queue_item)
            self.logger.info(f"评论已加入队列: ID={comment.id}, 队列长度={len(self._message_queue)}")
            
            # 如果没有正在处理的消息，启动处理
            if not self._is_processing:
                self.logger.info("队列空闲，开始处理队列")
                # 使用新线程启动队列处理，避免阻塞当前线程
                processing_thread = threading.Thread(target=self._process_next_in_queue)
                processing_thread.daemon = True
                processing_thread.start()
    
    def _process_next_in_queue(self) -> None:
        """
        处理队列中的下一条消息
        """
        # 使用锁获取队列状态
        with self._queue_lock:
            # 如果队列为空或已经有处理中的消息，不做任何操作
            if not self._message_queue or self._is_processing:
                self.logger.debug(f"跳过队列处理: 队列为空={not self._message_queue}, 正在处理={self._is_processing}")
                return
            
            # 标记为正在处理
            self._is_processing = True
            # 获取队列中的第一条消息
            item = self._message_queue.pop(0)
        
        # 记录日志
        comment = item["comment"]
        self.logger.info(f"开始处理队列中的消息: ID={comment.id}, 类型={item['type']}")
        
        try:
            # 处理队列项目
            self._process_queue_item(item)
        except Exception as e:
            self.logger.error(f"处理队列项目时发生异常: {str(e)}")
            import traceback
            self.logger.error(traceback.format_exc())
            
            # 重置处理状态
            with self._queue_lock:
                self._is_processing = False
            
            # 继续处理下一条消息
            self._process_next_in_queue()
    
    def _process_queue_item(self, item: Dict[str, Any]) -> None:
        """
        处理队列中的单个项目
        
        @param item: 队列项目
        """
        comment = item["comment"]
        prompt = item["prompt"]
        process_type = item["type"]
        
        try:
            self.logger.info(f"处理队列项目: ID={comment.id}, 类型={process_type}")
            
            # 根据处理类型分别处理
            if process_type == "analyze":
                # 调用同步分析方法
                result = self.analyze_comment(comment)
                self.logger.info(f"评论分析完成: ID={comment.id}, 结果源={result.get('source', 'unknown')}")
            elif process_type == "reply":
                # 生成回复
                reply = self.generate_reply(comment, prompt)
                comment.reply = reply
                result = {
                    "comment_id": comment.id,
                    "reply": reply,
                    "timestamp": time.time()
                }
                self.logger.info(f"回复生成完成: ID={comment.id}")
                # 触发回复生成事件
                self.notify("reply_generated", result)
            else:
                self.logger.warning(f"未知的处理类型: {process_type}")
        except Exception as e:
            self.logger.error(f"处理队列项目失败: {str(e)}")
            import traceback
            self.logger.error(traceback.format_exc())
        finally:
            # 处理完成，重置状态
            with self._queue_lock:
                self._is_processing = False
            
            # 处理下一条消息
            self._process_next_in_queue() 

    def _validate_token_format(self, token: str) -> bool:
        """
        验证token格式
        
        @param token: token字符串
        @return: 是否有效
        """
        # 检查token是否为空
        if not token or not isinstance(token, str):
            return False
            
        # 检查token是否以pat_开头
        if not token.startswith("pat_"):
            return False
            
        # 检查token长度
        if len(token) < 20:  # 设置一个合理的最小长度
            return False
            
        return True
    
    def _test_api_connection(self, token: str) -> bool:
        """
        测试API连接
        
        @param token: token字符串
        @return: 是否连接成功
        """
        try:
            coze = Coze(
                auth=TokenAuth(token=token),
                base_url=COZE_CN_BASE_URL
            )
            
            # 测试连接
            list(coze.workspaces.list())
            return True
        except Exception as e:
            self.logger.error(f"API连接测试失败: {str(e)}")
            return False
    
    def update_token(self, token: str) -> bool:
        """
        更新token
        
        @param token: 新的token
        @return: 是否更新成功
        """
        try:
            # 1. 验证token格式
            if not self._validate_token_format(token):
                raise ValueError("Token格式无效")
                
            # 2. 测试API连接
            if not self._test_api_connection(token):
                raise ConnectionError("无法连接到API，请检查Token是否正确")
                
            # 3. 更新配置
            self._config["token"] = token
            
            # 4. 重新初始化Coze客户端
            self._coze = Coze(
                auth=TokenAuth(token=token),
                base_url=COZE_CN_BASE_URL
            )
            
            self.logger.info("Token更新成功")
            self.notify("ai_connection_status", "success")
            return True
            
        except Exception as e:
            self.logger.error(f"Token更新失败: {str(e)}")
            self.notify("ai_connection_status", "failed")
            return False
    
    def configure(self, config: Dict[str, Any]) -> None:
        """
        配置AI服务
        
        @param config: 配置字典
        """
        # 更新配置
        self._config.update(config)
        
        # 如果更新了token，尝试更新连接
        if "token" in config:
            token = config["token"]
            if token:
                self.update_token(token)
        
        self.logger.info("AI服务配置已更新") 